
//
//  ClassFunc.swift
//  Swift3.0_Study
//
//  Created by chengfeng on 2016/9/29.
//  Copyright © 2016年 zhaochengfeng. All rights reserved.
//

import Cocoa

class ClassFunc: NSObject {

    func start() -> Void {
        //--------------------------方法-----------------------
        //1实例方法(有对象调用)
        // 1> 不参数的实例方法
        // 2>带一个参数的实例方法
        // 3>带多个参数的实例方法
        class ClassA {
            var str = "hello"
            func printHello(){
                print(str)
            }
        }
        
        let clsA = ClassA()
        clsA.printHello()
        
        
        class AddClass {
            var count: Int = 0
            func add(amount1: Int, amount2: Int){
                count = amount1 + amount2
                print(count)
            }
        }
        let counter = AddClass()
        counter.add(amount1: 100, amount2: 200)
        
        //2类型方法 由类调用
        //  1>无参数的类方法
        //  2>一个参数的类方法
        //  3>多个参数的类方法
        
        class MutiplyClass {
            
            var number: Int = 0//存储属性
            
            class func Mutiply(amount1: Int, amount2: Int){
                var count: Int = 0
                count = amount1 * amount2
                print(count)
                // print(number)  @1不可以使用存储属性
            }
        }
        //注意事项
        //@1不可以使用存储属性
        //@2类调用
        //@3外部参数名,和实例方法相同,swift 默认给类型的第一个参数一个局部参数名称,默认同时给第二个和后续的参数一个局部参数名称和外部参数名称,调用时不要忘记外部参数名
        
        
        //3.存储属性,局部变量和全局变量的区别
        //存储属性定义在类中,
        //局部变量定义在函数,方法或闭包内部,
        //全局变量定义在函数,方法,闭包或者任何类型之外定义的变量
        
        
        //4局部变量和存储属性同名解决的方法 self
        
        class ClassB {
            var count: Int = 100
            func printCount() {
                self.count = 50
                print(self.count)
            }
        }
        let clsB = ClassB()
        clsB.printCount()
        
        
        enum 怪物经验表: Int {
            case 骷髅 = 80, 掷斧骷髅 = 100, 骷髅教主 = 300
        }
        
        struct 服务器经验倍数 {
            var 开启 = false
            var 倍数 = 1
        }
        
        class 人民币玩家 {
            var 经验值 = 0
            var 经验倍数 = 服务器经验倍数()
            
            func 挂机经验() {
                经验值 += 500
                print("挂机成功一次! 经验为\(经验值)")
            }
            
            func 打怪经验(怪物: 怪物经验表, 经验倍数: Int) {
                let 怪物经验值 = 怪物.rawValue
                
                self.经验值 += (怪物经验值 * 经验倍数)
                
                if self.经验倍数.开启 && self.经验倍数.倍数 > 1 {
                    经验值 *= self.经验倍数.倍数
                }
                print("当前打怪经验值是\(self.经验值)")
            }
        }
        
        let 小波 = 人民币玩家()
        小波.挂机经验()
        小波.打怪经验(怪物: 怪物经验表.骷髅教主, 经验倍数: 3)
        
        小波.经验倍数.开启 = true
        小波.经验倍数.倍数 = 10
        小波.打怪经验(怪物: 怪物经验表.掷斧骷髅, 经验倍数: 3)
        
        
        //:  - 结构体/枚举实例默认不可改变属性值. 若需要修改,须加上mutating关键字.
        struct 角色坐标 {
            var x = 0, y = 0
            
            mutating func 安全区坐标(x: Int, y: Int) {
                self.x = x
                self.y = y
                print("当前已回到安全区,坐标是\(self.x),\(self.y)")
            }
        }
        
        var 小波的坐标 = 角色坐标()
        小波的坐标.安全区坐标(x: 888, y: 999)
        
        
        enum 猜拳 {
            case 石头,剪刀,布
            
            static let game = "猜拳"
            
            mutating func 开始() {
                print("我出的是\(self)")
                
                switch self {
                case .剪刀 :
                    self = 猜拳.石头
                case .石头:
                    self = 猜拳.布
                case .布:
                    self = 猜拳.剪刀
                }
                
                
            }
        }
        
        var 小波2 = 猜拳.剪刀
        
        小波2.开始()
        
        print(小波2)
    }
}

